﻿
#include "zyListView.h"

DarkMoonUI::zyListView::zyListView()
{
	SetMember(L"this", (LONG_PTR)this);
	m_obj->setWndProc(zyListView_WndProc);
	m_obj->setChildWndProc(zyListView_ChildWndProc);
	m_obj->setDestroy(zyListView_Destroy);
}
DarkMoonUI::zyListView::~zyListView()
{

}
void WINAPI DarkMoonUI::zyListView::zyListView_Destroy(zyObject* obj)
{
	zyListView* zyb = (zyListView*)obj->getPtrData(L"this");
	zyb->OnNCDestroy();
	zyCtrol::zyCtrol_Destroy(obj);
}
LRESULT WINAPI DarkMoonUI::zyListView::zyListView_ChildWndProc(zyObject* obj, HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam, BOOL* bHandle)
{
	if (message == WM_NOTIFY)
	{
		NMHDR* pNMHDR = reinterpret_cast<NMHDR*>(lParam);
		
	}
	return zyCtrol::zyCtrol_ChildWndProc(obj, hWnd, message, wParam, lParam, bHandle);
}
LRESULT WINAPI DarkMoonUI::zyListView::zyListView_WndProc(zyObject* obj, HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL* bHandle)
{
	if (uMsg == WM_NCDESTROY) {
		zyListView* zyb = (zyListView*)obj->getPtrData(L"this");
		zyb->OnNCDestroy();
	}
	return zyCtrol::zyCtrol_WndProc(obj, hWnd, uMsg, wParam, lParam, bHandle);
}
void DarkMoonUI::zyListView::OnNCDestroy() {
	LONG_PTR pImageList = GetMember(L"pImageList");
	if (pImageList != 0) {
		//IUnknown_Release (pImageList);
		//pImageList->getObject()->release();
		//delete pImageList;
		SetMember(L"pImageList", 0);
	}

}
BOOL DarkMoonUI::zyListView::创建(HWND 参数_父窗口, const std::wstring& 参数_标题, POINT 参数_位置, POINT 参数_尺寸, int 参数_ID, int 参数_窗口风格, int 参数_扩展风格)
{
	if (参数_ID == NULL)
		参数_ID = 黑月默认ID();
	if (参数_扩展风格 == 0)
		参数_扩展风格 = WS_EX_CLIENTEDGE;
	bool b = _CreateCtrol(参数_父窗口, 参数_标题, 参数_位置, 参数_尺寸, 参数_ID, 参数_窗口风格, 参数_扩展风格, L"SysListView32");
	if (b)
		sendMsg(LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_SUBITEMIMAGES | LVS_EX_INFOTIP);
	return b;
}
BOOL DarkMoonUI::zyListView::创建(zyWindow& 参数_父窗口, const std::wstring& 参数_标题, POINT 参数_位置, POINT 参数_尺寸, int 参数_ID, int 参数_窗口风格, int 参数_扩展风格)
{
	if (参数_ID == NULL)
		参数_ID = 黑月默认ID();
	if(参数_扩展风格 ==0)
		参数_扩展风格 = WS_EX_CLIENTEDGE;
	bool b = _CreateCtrol(参数_父窗口.getHwnd(), 参数_标题, 参数_位置, 参数_尺寸, 参数_ID, 参数_窗口风格, 参数_扩展风格, L"SysListView32");
	if (b)
		sendMsg(LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_SUBITEMIMAGES | LVS_EX_INFOTIP);
	return b;
}
int DarkMoonUI::zyListView::插入列(int 参数_插入位置, const std::wstring& 参数_标题文本, int 参数_列宽, int 参数_对齐方式, int 参数_图片索引, bool 参数_列图片是否居右) {//在报表型列表框中指定位置插入新的列，成功返回新列的位置索引，失败返回 -1 。
	LVCOLUMN column = {0};
	if (参数_插入位置 == -1)
		参数_插入位置 = 取列数();
	if (参数_图片索引 != -1)
		column.mask = LVCF_IMAGE;
	if (参数_对齐方式 == -1)
		参数_对齐方式 = LVCFMT_LEFT;
	if (参数_列宽 == -1)
		参数_列宽 = 50;
	if (参数_列图片是否居右)
		参数_对齐方式 = 参数_对齐方式 | LVCFMT_BITMAP_ON_RIGHT;
	column.mask = column.mask | LVCF_FMT | LVCF_TEXT | LVCF_WIDTH;
	column.fmt = 参数_对齐方式;
	column.cx = 参数_列宽;
	column.pszText = (LPWSTR)参数_标题文本.c_str();
	column.cchTextMax = (int)参数_标题文本.size();
	column.iImage = 参数_图片索引;
	return (int)sendMsg(LVM_INSERTCOLUMNW, 参数_插入位置, (LPARAM)&column);
}
int DarkMoonUI::zyListView::取列数() {//返回报表型列表框中列的总数
	HWND 表头句柄 = (HWND)sendMsg(LVM_GETHEADER, 0, 0);
	return (int)SendMessage(表头句柄, HDM_GETITEMCOUNT, 0, 0);
}
int DarkMoonUI::zyListView::取表项数() {
	return (int)sendMsg(LVM_GETITEMCOUNT, 0, 0);
}
int DarkMoonUI::zyListView::插入表项(int 参数_插入位置, const std::wstring& 参数_标题文本, int 参数_图片索引, int 参数_状态图片索引, int 参数_缩进数目, int 参数_项目数值, int 参数_分组ID) {//在指定的位置插入新表项，成功返回新表项的位置索引，失败返回 -1 
	LVITEM item = {0};
	item.mask = LVIF_IMAGE | LVIF_PARAM | LVIF_STATE | LVIF_INDENT;
	if (参数_插入位置 == -1)
		参数_插入位置 = 取表项数();
	if (参数_标题文本.size() > 0)
		item.mask = item.mask | LVIF_TEXT;
	if (参数_分组ID != -1)
		item.mask = item.mask | LVIF_GROUPID;
	item.iItem = 参数_插入位置;
	item.iSubItem = 0;
	item.state = (参数_状态图片索引 + 1) << 12;
	item.stateMask = LVIS_STATEIMAGEMASK;
	item.pszText = (LPWSTR)参数_标题文本.c_str();
	item.cchTextMax = (int)参数_标题文本.size();
	item.iImage = 参数_图片索引;
	item.lParam = 参数_项目数值;
	item.iIndent = 参数_缩进数目;
	item.iGroupId = 参数_分组ID;
	return (int)sendMsg(LVM_INSERTITEMW, 0, (LPARAM)&item);
}
bool DarkMoonUI::zyListView::置标题(int 参数_表项索引, int 参数_列索引, const std::wstring& 参数_欲置入标题) {//设置指定表项或子项的标题
	LVITEM item = {0};
	item.mask = LVIF_TEXT;
	item.iItem = 参数_表项索引;
	item.iSubItem = 参数_列索引;
	item.pszText = (LPWSTR)参数_欲置入标题.c_str();
	item.cchTextMax = (int)参数_欲置入标题.size();
	return sendMsg(LVM_SETITEMW, 0, (LPARAM)&item) != 0;
}
bool DarkMoonUI::zyListView::绑定(HWND 参数_父窗口, int 参数_资源ID, bool 参数_使用默认字体) {//成功返回真，失败返回假。
	HWND hwnd = GetDlgItem(参数_父窗口, 参数_资源ID);
	if (hwnd != 0) {
		SendMessage(hwnd, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_SUBITEMIMAGES | LVS_EX_INFOTIP);
		if (参数_使用默认字体 && hwnd != 0) {
			SendMessage(hwnd, WM_SETFONT, (WPARAM)GetStockObject(DEFAULT_GUI_FONT), 0);
		}
	}
	return _BindWindow(hwnd);
}
bool DarkMoonUI::zyListView::绑定窗口句柄(HWND 参数_窗口句柄) {
	if (IsWindow(参数_窗口句柄) != 0) {
		SendMessage(参数_窗口句柄, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, LVS_EX_SUBITEMIMAGES | LVS_EX_INFOTIP);
	}
	return _BindWindow(参数_窗口句柄);
}
int DarkMoonUI::zyListView::插入分组(int 参数_插入位置, int 参数_分组ID, const std::wstring& 参数_组头标题, const std::wstring& 参数_页脚标题, int 参数_对齐方式, int 参数_状态) {
	LVGROUP lvg = { 0 };
	if (参数_对齐方式 == NULL) {
		参数_对齐方式 = LVGA_HEADER_LEFT | LVGA_FOOTER_LEFT;
	}
	lvg.cbSize = sizeof(LVGROUP);
	lvg.mask = LVGF_GROUPID | LVGF_HEADER | LVGF_FOOTER | LVGF_ALIGN | LVGF_STATE;
	lvg.iGroupId = 参数_分组ID;
	lvg.pszHeader = (LPWSTR)参数_组头标题.c_str();
	lvg.pszFooter = (LPWSTR)参数_页脚标题.c_str();
	lvg.uAlign = 参数_对齐方式;
	lvg.state = 参数_状态;
	lvg.stateMask = 参数_状态;
	int ret = (int)sendMsg(LVM_INSERTGROUP, 参数_插入位置, (LPARAM)&lvg);
	return ret;
}
bool DarkMoonUI::zyListView::启用分组(bool 参数_是否启用) {//必须要启用Window通用组件6.0版 参数留空为取，否则为置
	if (!参数_是否启用) {
		return sendMsg(LVM_ISGROUPVIEWENABLED, 0, 0) != 0;
	}
	else {
		return sendMsg(LVM_ENABLEGROUPVIEW, 参数_是否启用, 0) != -1;
	}
}
int DarkMoonUI::zyListView::取表项分组ID(int 参数_表项索引) {//必须要启用Window通用组件6.0版
	LVITEM item = { 0 };
	item.mask = LVIF_GROUPID;
	item.iItem = 参数_表项索引;
	sendMsg(LVM_GETITEMW, 0, (LPARAM)&item);
	return item.iGroupId;
}
bool DarkMoonUI::zyListView::置表项分组ID(int 参数_表项索引, int 参数_分组ID) {//必须要启用Window通用组件6.0版 设置指定表项的分组ID
	LVITEM item = { 0 };
	item.mask = LVIF_GROUPID;
	item.iItem = 参数_表项索引;
	item.iGroupId = 参数_分组ID;
	return sendMsg(LVM_SETITEMW, 0, (LPARAM)&item) != 0;
}
std::wstring DarkMoonUI::zyListView::取分组头标题(int 参数_分组ID) {//必须要启用Window通用组件6.0版
	LVGROUP lvg = { 0 };
	lvg.cbSize = sizeof(LVGROUP);
	lvg.mask = LVGF_HEADER;
	std::wstring pszHeader;
	pszHeader.reserve(520);
	lvg.pszHeader = (LPWSTR)pszHeader.c_str();
	lvg.cchHeader = 260;
	sendMsg(LVM_GETGROUPINFO, 参数_分组ID, (LPARAM)&lvg);
	return pszHeader;
}
std::wstring DarkMoonUI::zyListView::取分组页脚标题(int 参数_分组ID) {//必须要启用Window通用组件6.0版
	LVGROUP lvg = { 0 };
	lvg.cbSize = sizeof(LVGROUP);
	lvg.mask = LVGF_FOOTER;
	std::wstring pszFooter;
	pszFooter.reserve(520);
	lvg.pszFooter = (LPWSTR)pszFooter.c_str();
	lvg.cchFooter = 260;
	sendMsg(LVM_GETGROUPINFO, 参数_分组ID, (LPARAM)&lvg);
	return pszFooter;
}
int DarkMoonUI::zyListView::取分组对齐方式(int 参数_分组ID) {//必须要启用Window通用组件6.0版 返回"超列分组对齐_"开头常量组合
	LVGROUP lvg = { 0 };
	lvg.cbSize = sizeof(LVGROUP);
	lvg.mask = LVGF_ALIGN;
	sendMsg(LVM_GETGROUPINFO, 参数_分组ID, (LPARAM)&lvg);
	return lvg.uAlign;
}
bool DarkMoonUI::zyListView::置分组对齐方式(int 参数_分组ID, int 参数_对齐方式) {//必须要启用Window通用组件6.0版
	LVGROUP lvg = { 0 };
	lvg.cbSize = sizeof(LVGROUP);
	lvg.mask = LVGF_ALIGN;
	lvg.state = 参数_对齐方式;
	return sendMsg(LVM_SETGROUPINFO, 参数_分组ID, (LPARAM)&lvg) != -1;
}
bool DarkMoonUI::zyListView::置分组头标题(int 参数_分组ID, const std::wstring& 参数_标题) {//必须要启用Window通用组件6.0版
	LVGROUP lvg = { 0 };
	lvg.cbSize = sizeof(LVGROUP);
	lvg.mask = LVGF_HEADER;
	lvg.pszHeader = (LPWSTR)参数_标题.c_str();
	lvg.cchHeader = (int)参数_标题.size();
	return sendMsg(LVM_SETGROUPINFO, 参数_分组ID, (LPARAM)&lvg) != -1;
}
bool DarkMoonUI::zyListView::置分组页脚标题(int 参数_分组ID, const std::wstring& 参数_标题) {//必须要启用Window通用组件6.0版
	LVGROUP lvg = { 0 };
	lvg.cbSize = sizeof(LVGROUP);
	lvg.mask = LVGF_HEADER;
	lvg.pszFooter = (LPWSTR)参数_标题.c_str();
	lvg.cchFooter = (int)参数_标题.size();
	return sendMsg(LVM_SETGROUPINFO, 参数_分组ID, (LPARAM)&lvg) != -1;
}
int DarkMoonUI::zyListView::取分组状态(int 参数_分组ID) {//必须要启用Window通用组件6.0版
	LVGROUP lvg = { 0 };
	lvg.cbSize = sizeof(LVGROUP);
	lvg.mask = LVGF_STATE;
	sendMsg(LVM_GETGROUPINFO, 参数_分组ID, (LPARAM)&lvg);
	return lvg.state;
}
bool DarkMoonUI::zyListView::置分组状态(int 参数_分组ID, int 参数_状态) {//必须要启用Window通用组件6.0版
	LVGROUP lvg = { 0 };
	lvg.cbSize = sizeof(LVGROUP);
	lvg.mask = LVGF_STATE;
	lvg.stateMask = 参数_状态;
	lvg.state = 参数_状态;
	return sendMsg(LVM_SETGROUPINFO, 参数_分组ID, (LPARAM)&lvg) != -1;
}
int DarkMoonUI::zyListView::取分组ID(int 参数_分组索引) {//必须要启用Window通用组件6.0版
	LVGROUP lvg = { 0 };
	lvg.cbSize = sizeof(LVGROUP);
	lvg.mask = LVGF_GROUPID;
	sendMsg(LVM_GETGROUPINFOBYINDEX, 参数_分组索引, (LPARAM)&lvg);
	return lvg.iGroupId;
}
bool DarkMoonUI::zyListView::排序分组(void* 参数_回调函数, LPARAM 参数_用户数据) {//必须要启用Window通用组件6.0版
	return sendMsg(LVM_SORTGROUPS, (WPARAM)参数_回调函数, 参数_用户数据) != 0;
}
std::wstring DarkMoonUI::zyListView::取标题(int 参数_表项索引, int 参数_列索引, int 参数_长度) {//取指定表项或子项的标题
	LVITEM item = { 0 };
	//CXText pszText;
	item.mask = LVIF_TEXT;
	//pszText.reserve(参数_长度);
	wchar_t buffer[MAX_PATH]{};
	item.pszText = buffer;
	item.cchTextMax = 参数_长度;
	item.iSubItem = 参数_列索引;
	item.iItem = 参数_表项索引;
	int ret = (int)sendMsg(LVM_GETITEMW, 0, (LPARAM)&item);
	if (ret != 0)
		return buffer;
	return L"";
}
int DarkMoonUI::zyListView::取图片(int 参数_表项索引, int 参数_列索引) {
	LVITEM item = { 0 };
	item.mask = LVIF_IMAGE;
	item.iItem = 参数_表项索引;
	item.iSubItem = 参数_列索引;
	sendMsg(LVM_GETITEMW, 0, (LPARAM)&item);
	return item.iImage;
}
int DarkMoonUI::zyListView::取状态图片(int 参数_表项索引) {
	int state = (int)sendMsg(LVM_GETITEMSTATE, 参数_表项索引, LVIS_STATEIMAGEMASK);
	return (state >> 12) - 1;
}
int DarkMoonUI::zyListView::取缩进数目(int 参数_表项索引) {//取回指定表项的缩进数目
	LVITEM item = {0};
	item.mask = LVIF_INDENT;
	item.iItem = 参数_表项索引;
	sendMsg(LVM_GETITEMW, 0, (LPARAM)&item);
	return item.iIndent;
}
int DarkMoonUI::zyListView::取表项数值(int 参数_表项索引) {//返回与指定表项相关联的数值
	LVITEM item = { 0 };
	item.mask = LVIF_PARAM;
	item.iItem = 参数_表项索引;
	sendMsg(LVM_GETITEMW, 0, (LPARAM)&item);
	return (int)item.lParam;
}
int DarkMoonUI::zyListView::取表项状态(int 参数_表项索引) {//返回"超列状态_"开头常量组合
	int state = (int)sendMsg(LVM_GETITEMSTATE, 参数_表项索引, 255);
	return (state & 255);
}
bool DarkMoonUI::zyListView::置表项状态(int 参数_表项索引, int 参数_添加的状态, int 参数_移除的状态) {
	LVITEM item = { 0 };
	item.mask = LVIF_STATE;
	item.stateMask = 255;
	item.state = 参数_添加的状态;
	item.state = item.state & (~参数_移除的状态);
	return sendMsg(LVM_SETITEMSTATE, 参数_表项索引, (LPARAM)&item) != 0;
}
bool DarkMoonUI::zyListView::置图片(int 参数_表项索引, int 参数_列索引, int 参数_图片索引) {//设置指定表项或子项的图片
	LVITEM item = { 0 };
	item.mask = LVIF_IMAGE;
	item.iItem = 参数_表项索引;
	item.iSubItem = 参数_列索引;
	item.iImage = 参数_图片索引;
	return sendMsg(LVM_SETITEMW, 0, (LPARAM)&item) != 0;
}
bool DarkMoonUI::zyListView::置状态图片(int 参数_表项索引, int 参数_状态图片索引) {//设置指定表项的状态图片。如果包含"超列扩展_显示检查框"风格，可以设置表项检查框的选中状态
	LVITEM item = { 0 };
	item.mask = LVIF_STATE;
	item.iItem = 参数_表项索引;
	item.state = (参数_状态图片索引 + 1) << 12;
	item.stateMask = LVIS_STATEIMAGEMASK;
	return sendMsg(LVM_SETITEMW, 0, (LPARAM)&item) != 0;
}
bool DarkMoonUI::zyListView::置缩进数目(int 参数_表项索引, int 参数_缩进数目) {//设置指定表项的缩进数目
	LVITEM item = { 0 };
	item.mask = LVIF_INDENT;
	item.iItem = 参数_表项索引;
	item.iIndent = 参数_缩进数目;
	return sendMsg(LVM_SETITEMW, 0, (LPARAM)&item) != 0;
}
bool DarkMoonUI::zyListView::置表项数值(int 参数_表项索引, int 参数_表项数值) {//设置与指定表项相关联的数值
	LVITEM item = { 0 };
	item.mask = LVIF_PARAM;
	item.iItem = 参数_表项索引;
	item.lParam = 参数_表项数值;
	return sendMsg(LVM_SETITEMW, 0, (LPARAM)&item) != 0;
}
int DarkMoonUI::zyListView::取被选择表项(std::vector<int>& 参数_被选择表项数组) {//返回选择表项数
	参数_被选择表项数组.clear();
	int 局部_成员数 = (int)sendMsg(LVM_GETITEMCOUNT, 0, 0);  // 取表项数;
	for (int 计次 = 0; 计次 < 局部_成员数; 计次++) {
		if (sendMsg(LVM_GETITEMSTATE, 计次, LVIS_SELECTED) == LVIS_SELECTED) // 是否被选择{
			参数_被选择表项数组.push_back(计次);
	}
	return (int)参数_被选择表项数组.size();
}
int DarkMoonUI::zyListView::取被选中表项(std::vector<int>& 参数_被选中表项数组) {//如果"是否有检查框"属性为真，返回选中表项数
	参数_被选中表项数组.clear();
	int 局部_成员数 = (int)sendMsg(LVM_GETITEMCOUNT, 0, 0);  // 取表项数;
	for (int 计次 = 0; 计次 < 局部_成员数; 计次++) {
		int state = (int)sendMsg(LVM_GETITEMSTATE, 计次 - 1, LVIS_STATEIMAGEMASK);
		if ((state & LVIS_STATEIMAGEMASK) != 4096)  // 是否被选中{
			参数_被选中表项数组.push_back(计次);
	}
	return (int)参数_被选中表项数组.size();
}
bool DarkMoonUI::zyListView::置现行选中项(int 参数_表项索引) {//设置现行选择项目
	sendMsg(LVM_SETSELECTIONMARK, 0, 参数_表项索引);
	if (参数_表项索引 == -1)
		return 取消表项选择(参数_表项索引);
	else
		return 选择表项(参数_表项索引);
}
bool DarkMoonUI::zyListView::选择表项(int 参数_表项索引) {//选择指定表项。
	LVITEM item = { 0 };
	item.mask = LVIF_STATE;
	item.iItem = 参数_表项索引;
	item.state = LVIS_SELECTED;
	item.stateMask = LVIS_SELECTED;
	return sendMsg(LVM_SETITEMSTATE, 参数_表项索引, (LPARAM)&item) != 0;
}
bool DarkMoonUI::zyListView::取消表项选择(int 参数_表项索引) {//取消对指定表项的选择
	LVITEM item = { 0 };
	item.mask = LVIF_STATE;
	item.iItem = 参数_表项索引;
	item.state = ~LVIS_SELECTED;
	item.stateMask = LVIS_SELECTED;
	return sendMsg(LVM_SETITEMSTATE, 参数_表项索引, (LPARAM)&item) != 0;
}
int DarkMoonUI::zyListView::查找表项(const std::wstring& 参数_标题文本, int 参数_起始位置, bool 参数_是否精确匹配, bool 参数_查找不到是否从头开始) {//查找具有指定标题的表项，成功返回被找到表项的位置索引，失败返回 -1
	LVFINDINFO lvfi = { 0 };
	int flags;
	if (参数_是否精确匹配) {
		flags = LVFI_STRING;
	}
	else {
		flags = LVFI_PARTIAL;
	}
	if (参数_查找不到是否从头开始) {
		flags = flags | LVFI_WRAP;
	}
	lvfi.flags = flags;
	lvfi.psz = (LPWSTR)参数_标题文本.c_str();
	int ret = (int)sendMsg(LVM_FINDITEMW, 参数_起始位置, (LPARAM)&lvfi);
	return ret;
}
int DarkMoonUI::zyListView::查找表项数值(int 参数_表项数值, int 参数_起始位置, bool 参数_查找不到是否从头开始) {//查找具有指定表项数值，成功返回被找到表项的位置索引，失败返回 -1
	LVFINDINFO lvfi = { 0 };
	int flags = 0;
	if (参数_查找不到是否从头开始) {
		flags = LVFI_WRAP;
	}
	lvfi.flags = flags | LVFI_PARAM;
	lvfi.lParam = 参数_表项数值;
	int ret = (int)sendMsg(LVM_FINDITEMW, 参数_起始位置, (LPARAM)&lvfi);
	return ret;
}
bool DarkMoonUI::zyListView::保证显示(int 参数_表项索引, bool 参数_是否保证显示) {//确保指定表项能够显示出来，如果不能显示，则自动滚动并显示该表项
	return sendMsg(LVM_ENSUREVISIBLE, 参数_表项索引, 参数_是否保证显示 ? 1 : 0) != 0;
}
bool DarkMoonUI::zyListView::自动排列(bool 参数_对齐到网格) {//自动排列大图标或小图标列表框中的图标。
	return sendMsg(LVM_ARRANGE, 参数_对齐到网格 ? LVA_SNAPTOGRID : 0, 0) != 0;
}
std::wstring DarkMoonUI::zyListView::取列标题(int 参数_列索引) {
	LVCOLUMN column = { 0 };
	std::wstring pszText;
	column.mask = LVCF_TEXT;
	pszText.reserve(520);
	column.pszText = (LPWSTR)pszText.c_str();
	column.cchTextMax = 260;
	if (sendMsg(LVM_GETCOLUMNW, 参数_列索引, (LPARAM)&column) != 0)
		return pszText;
	return L"";
}
int DarkMoonUI::zyListView::取列对齐方式(int 参数_列索引) {//取回报表型列表框中指定列的对齐方式。返回"超列对齐_"开头常量；失败返回-1。
	LVCOLUMN column = { 0 };
	column.mask = LVCF_FMT;
	int ret = (int)sendMsg(LVM_GETCOLUMNW, 参数_列索引, (LPARAM)&column);
	if (ret == 0)
		return -1;
	if ((column.fmt & LVCFMT_LEFT) == LVCFMT_LEFT)
		return LVCFMT_LEFT;
	else if ((column.fmt & LVCFMT_RIGHT) == LVCFMT_RIGHT)
		return LVCFMT_RIGHT;
	else if ((column.fmt & LVCFMT_CENTER) == LVCFMT_CENTER)
		return LVCFMT_CENTER;
	return -1;
}
bool DarkMoonUI::zyListView::置列对齐方式(int 参数_列索引, int 参数_对齐方式) {
	LVCOLUMN column = { 0 };
	column.mask = LVCF_FMT;
	column.fmt = 参数_对齐方式;
	return sendMsg(LVM_SETCOLUMNW, 参数_列索引, (LPARAM)&column) != 0;
}
int DarkMoonUI::zyListView::取列宽(int 参数_列索引) {//返回报表型列表框中指定列的宽度，如指定列不存在，返回 0
	return (int)sendMsg(LVM_GETCOLUMNWIDTH, 参数_列索引, 0);
}
int DarkMoonUI::zyListView::取现行选择列() {//返回列索引。
	return (int)sendMsg(LVM_GETSELECTEDCOLUMN, 0, 0);
}
void DarkMoonUI::zyListView::置现行选择列(int 参数_列索引) {
	sendMsg(LVM_SETSELECTEDCOLUMN, 参数_列索引, 0);
}
int DarkMoonUI::zyListView::取列图片(int 参数_列索引) {//返回报表型列表框中指定列的图片索引
	LVCOLUMN column = { 0 };
	column.mask = LVCF_IMAGE | LVCF_FMT;
	int ret = (int)sendMsg(LVM_GETCOLUMNW, 参数_列索引, (LPARAM)&column);
	if (ret != 0)
		return column.iImage;
	return -1;
}
bool DarkMoonUI::zyListView::图片是否居右(int 参数_列索引) {//如果报表型列表框中指定列的图片居右显示，返回真，否则返回假
	LVCOLUMN column = { 0 };
	column.mask = LVCF_IMAGE | LVCF_FMT;
	int ret = (int)sendMsg(LVM_GETCOLUMNW, 参数_列索引, (LPARAM)&column);
	if (ret != 0)
		return  (column.fmt & LVCFMT_BITMAP_ON_RIGHT) == LVCFMT_BITMAP_ON_RIGHT;
	return false;
}
bool DarkMoonUI::zyListView::置列标题(int 参数_列索引, const std::wstring& 参数_标题文本) {//设置报表型列表框中指定列的标题
	LVCOLUMN column = { 0 };
	column.mask = LVCF_TEXT;
	column.pszText = (LPWSTR)参数_标题文本.c_str();
	column.cchTextMax = (int)参数_标题文本.size();
	return sendMsg(LVM_SETCOLUMNW, 参数_列索引, (LPARAM)&column) != 0;
}
bool DarkMoonUI::zyListView::置列宽(int 参数_列索引, int 参数_欲置入宽度) {//设置报表型列表框中指定列的宽度，成功返回真，失败返回假。
	return sendMsg(LVM_SETCOLUMNWIDTH, 参数_列索引, 参数_欲置入宽度) != 0;
}
bool DarkMoonUI::zyListView::置列图片(int 参数_列索引, int 参数_图片索引) {//设置报表型列表框中指定列的标志图片
	LVCOLUMN column = { 0 };
	column.mask = LVCF_IMAGE;
	column.iImage = 参数_图片索引;
	return sendMsg(LVM_SETCOLUMNW, 参数_列索引, (LPARAM)&column) != 0;
}
bool DarkMoonUI::zyListView::取列矩形(int 参数_表项索引, int 参数_列索引, RECT& 参数_矩形结构, int 参数_取出类型) {//取出一个项目的矩形位置，可根据 "取出类型"参数，取出各种的矩形位置。成功返回真，失败返回假。
	参数_矩形结构.left = 参数_取出类型;
	参数_矩形结构.top = 参数_列索引;
	return sendMsg(LVM_GETSUBITEMRECT, 参数_表项索引, (LPARAM)&参数_矩形结构) != 0;
}
void DarkMoonUI::zyListView::进入编辑(int 参数_表项索引) {//让指定表项进入编辑状态，执行本命令成功的前提是"允许编辑"属性为真。
	GetFocus();
	sendMsg(LVM_EDITLABELW, 参数_表项索引, 0);
}
DarkMoonUI::zyListView::黑月超列信息 DarkMoonUI::zyListView::取项目数据(int 参数_表项索引) {//取指定项目的数据
	黑月超列信息 临时结构;
	LVITEM item = {0};
	std::wstring pszText;
	int 列数 = 取列数();
	item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM | LVIF_STATE | LVIF_INDENT;
	pszText.reserve(520);
	item.pszText = (LPWSTR)pszText.c_str();
	item.cchTextMax = 260;
	item.iItem = 参数_表项索引;
	item.iSubItem = 0;
	item.stateMask = LVIS_STATEIMAGEMASK;
	if (sendMsg(LVM_GETITEMW, 0, (LPARAM)&item) != 0) {
		临时结构.状态图片索引 = (item.state & LVIS_STATEIMAGEMASK) - 1;
		临时结构.图片索引 = item.iImage;
		临时结构.表项数值 = item.lParam;
		临时结构.缩进数目 = item.iIndent;
		临时结构.标题 = pszText;//取字节集左边 (pszText, lstrlenW (pszText) * 2 + 2);
		item.mask = LVIF_TEXT | LVIF_IMAGE;
		临时结构.列标题.resize(列数);
		临时结构.列图片索引.resize(列数);
		for (int i = 0; i < 列数; i++) {
			pszText.reserve(520);
			item.pszText = (LPWSTR)pszText.c_str();
			item.cchTextMax = 260;
			item.iSubItem = i;
			if (sendMsg(LVM_GETITEMW, 0, (LPARAM)&item) != 0) {
				临时结构.列标题[i] = pszText;//取字节集左边 (pszText, lstrlenW (pszText) * 2 + 2);
				临时结构.列图片索引[i] = item.iImage;
			}
		}
	}
	return 临时结构;
}
int DarkMoonUI::zyListView::取所有项目数据(std::vector<黑月超列信息>& 参数_列表框信息数组) {//返回项目数。
	LVITEM item = {0};
	std::wstring pszText;
	int 局部_行数 = (int)sendMsg(LVM_GETITEMCOUNT, 0, 0);
	int 局部_列数 = 取列数();
	参数_列表框信息数组.resize(局部_行数);
	for (int i = 0; i < 局部_行数; i++) {
		item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM | LVIF_STATE | LVIF_INDENT;
		pszText.reserve(520);
		item.pszText = (LPWSTR)pszText.c_str();
		item.cchTextMax = 260;
		item.iItem = i;
		item.iSubItem = 0;
		item.stateMask = LVIS_STATEIMAGEMASK;
		if (sendMsg(LVM_GETITEMW, 0, (LPARAM)&item) != 0) {
			参数_列表框信息数组[i].状态图片索引 = ((item.state & LVIS_STATEIMAGEMASK) >> 12) - 1;
			参数_列表框信息数组[i].图片索引 = item.iImage;
			参数_列表框信息数组[i].表项数值 = item.lParam;
			参数_列表框信息数组[i].缩进数目 = item.iIndent;
			参数_列表框信息数组[i].标题 = pszText;
			item.mask = LVIF_TEXT | LVIF_IMAGE;
			参数_列表框信息数组[i].列标题.resize(局部_列数);
			参数_列表框信息数组[i].列图片索引.resize(局部_列数);
			for (int j = 0; j < 局部_列数; j++) {
				pszText.reserve(520);
				item.pszText = (LPWSTR)pszText.c_str();
				item.cchTextMax = 260;
				item.iSubItem = j;
				if (sendMsg(LVM_GETITEMW, 0, (LPARAM)&item) != 0) {
					参数_列表框信息数组[i].列标题[j] = pszText;
					参数_列表框信息数组[i].列图片索引[j] = item.iImage;
				}
			}
		}
	}
	return 局部_行数;
}
void DarkMoonUI::zyListView::_快速排序(std::vector<黑月超列信息>& 参数_列表框信息数组, int 参数_左边, int 参数_右边, int 参数_排序方式, int 参数_列索引, bool 参数_逆向) {
	if (参数_排序方式 == 排序方式_不排序 || 参数_左边 >= 参数_右边)
		return;

	// 选择基准值（三数取中法）
	int mid = 参数_左边 + (参数_右边 - 参数_左边) / 2;
	if (参数_排序方式 == 排序方式_文本排序) {
		if (wcscmp(参数_列表框信息数组[mid].列标题[参数_列索引].c_str(), 参数_列表框信息数组[参数_左边].列标题[参数_列索引].c_str()) < 0)
			std::swap(参数_列表框信息数组[mid], 参数_列表框信息数组[参数_左边]);
		if (wcscmp(参数_列表框信息数组[参数_右边].列标题[参数_列索引].c_str(), 参数_列表框信息数组[mid].列标题[参数_列索引].c_str()) < 0)
			std::swap(参数_列表框信息数组[参数_右边], 参数_列表框信息数组[mid]);
	}
	else {
		if (_wtoi(参数_列表框信息数组[mid].列标题[参数_列索引].c_str()) < _wtoi(参数_列表框信息数组[参数_左边].列标题[参数_列索引].c_str()))
			std::swap(参数_列表框信息数组[mid], 参数_列表框信息数组[参数_左边]);
		if (_wtoi(参数_列表框信息数组[参数_右边].列标题[参数_列索引].c_str()) < _wtoi(参数_列表框信息数组[mid].列标题[参数_列索引].c_str()))
			std::swap(参数_列表框信息数组[参数_右边], 参数_列表框信息数组[mid]);
	}
	黑月超列信息 局部_基准值 = 参数_列表框信息数组[mid];

	int i = 参数_左边;
	int j = 参数_右边;

	while (i <= j) {
		if (参数_排序方式 == 排序方式_文本排序) {
			if (参数_逆向) {
				while (wcscmp(参数_列表框信息数组[i].列标题[参数_列索引].c_str(), 局部_基准值.列标题[参数_列索引].c_str()) > 0) i++;
				while (wcscmp(参数_列表框信息数组[j].列标题[参数_列索引].c_str(), 局部_基准值.列标题[参数_列索引].c_str()) < 0) j--;
			}
			else {
				while (wcscmp(参数_列表框信息数组[i].列标题[参数_列索引].c_str(), 局部_基准值.列标题[参数_列索引].c_str()) < 0) i++;
				while (wcscmp(参数_列表框信息数组[j].列标题[参数_列索引].c_str(), 局部_基准值.列标题[参数_列索引].c_str()) > 0) j--;
			}
		}
		else {
			int iValue = _wtoi(参数_列表框信息数组[i].列标题[参数_列索引].c_str());
			int jValue = _wtoi(参数_列表框信息数组[j].列标题[参数_列索引].c_str());
			int pivotValue = _wtoi(局部_基准值.列标题[参数_列索引].c_str());

			if (参数_逆向) {
				while (iValue > pivotValue) { i++; iValue = _wtoi(参数_列表框信息数组[i].列标题[参数_列索引].c_str()); }
				while (jValue < pivotValue) { j--; jValue = _wtoi(参数_列表框信息数组[j].列标题[参数_列索引].c_str()); }
			}
			else {
				while (iValue < pivotValue) { i++; iValue = _wtoi(参数_列表框信息数组[i].列标题[参数_列索引].c_str()); }
				while (jValue > pivotValue) { j--; jValue = _wtoi(参数_列表框信息数组[j].列标题[参数_列索引].c_str()); }
			}
		}

		if (i <= j) {
			std::swap(参数_列表框信息数组[i], 参数_列表框信息数组[j]);
			i++;
			j--;
		}
	}

	// 递归排序
	if (参数_左边 < j) _快速排序(参数_列表框信息数组, 参数_左边, j, 参数_排序方式, 参数_列索引, 参数_逆向);
	if (i < 参数_右边) _快速排序(参数_列表框信息数组, i, 参数_右边, 参数_排序方式, 参数_列索引, 参数_逆向);
}
void DarkMoonUI::zyListView::高速插入表项(int 参数_插入位置, std::vector<黑月超列信息>& 参数_列表框信息数组, int 参数_排序方式, int 参数_列索引, bool 参数_逆向) {
	std::vector<黑月超列信息> 局部_信息数组;
	int i = 0;
	int j = 0;
	LVITEM item;
	局部_信息数组 = 参数_列表框信息数组;
	_快速排序(局部_信息数组, 0, 0, 参数_排序方式, 参数_列索引, 参数_逆向);
	int 局部_成员数 = (int)局部_信息数组.size();
	if (参数_插入位置 == -1) {
		参数_插入位置 = 取表项数();
	}
	sendMsg(11, 0, 0);
	item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM | LVIF_STATE | LVIF_INDENT;
	item.stateMask = LVIS_STATEIMAGEMASK;
	item.cchTextMax = 260;
	while (i < 局部_成员数) {
		item.iItem = 参数_插入位置 + i;
		i = i + 1;
		item.iSubItem = 0;
		item.pszText = (LPWSTR)局部_信息数组[i].标题.c_str();
		item.iImage = 局部_信息数组[i].图片索引;
		item.iIndent = 局部_信息数组[i].缩进数目;
		item.lParam = 局部_信息数组[i].表项数值;
		item.state = (局部_信息数组[i].状态图片索引 + 1) << 12;
		int 局部_当前索引 = (int)sendMsg(LVM_INSERTITEMW, 0, (LPARAM)&item);
		if (局部_当前索引 != -1) {
			int 局部_标题成员数 = (int)局部_信息数组[i].列标题.size();
			int 局部_图片成员数 = (int)局部_信息数组[i].列图片索引.size();
			int 局部_列成员数 = 局部_标题成员数 > 局部_图片成员数 ? 局部_标题成员数 : 局部_图片成员数;
			while (j < 局部_列成员数) {
				j = j + 1;
				item.iSubItem = j - 1;
				if (j <= 局部_标题成员数) {
					item.pszText = (LPWSTR)局部_信息数组[i].列标题[j].c_str();
					item.mask = LVIF_TEXT;
				}
				else {
					item.pszText = nullptr;
					item.mask = 0;
				}
				if (j <= 局部_图片成员数) {
					item.iImage = 局部_信息数组[i].列图片索引[j];
					item.mask = item.mask | LVIF_IMAGE;
				}
				sendMsg(LVM_SETITEMW, 0, (LPARAM)&item);
			}
			j = 0;
			item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM | LVIF_STATE | LVIF_INDENT;
			item.stateMask = LVIS_STATEIMAGEMASK;
		}
	}
	sendMsg(11, 1, 0);
}
bool DarkMoonUI::zyListView::置表项(const std::vector<BYTE>& tableData) {
	if (tableData.empty()) {
		return sendMsg(LVM_DELETEALLITEMS, 0, 0) != 0;
	}

	size_t len = tableData.size();
	const BYTE* ptr = tableData.data();
	sendMsg(WM_SETREDRAW, FALSE, 0);

	LVITEM item = { 0 };
	item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM | LVIF_STATE | LVIF_INDENT;
	item.stateMask = LVIS_STATEIMAGEMASK;
	item.cchTextMax = 260;

	int idx = -1;
	bool error = false;

	for (size_t i = 0; i < len; ) {
		BYTE flags = ptr[i++];
		if (i >= len) {
			error = true;
			break;
		}

		item.iImage = *reinterpret_cast<const int*>(&ptr[i]);
		i += 4;
		if (i >= len) {
			error = true;
			break;
		}

		item.state = 0;

		i += 4;
		if (i >= len) {
			error = true;
			break;
		}

		item.iIndent = *reinterpret_cast<const int*>(&ptr[i]);
		i += 4;
		if (i >= len) {
			error = true;
			break;
		}

		item.lParam = *reinterpret_cast<const LPARAM*>(&ptr[i]);
		i += 4;
		if (i >= len) {
			error = true;
			break;
		}

		item.pszText = const_cast<LPWSTR>(reinterpret_cast<const wchar_t*>(&ptr[i])); // 改为 LPWSTR
		size_t strlen = lstrlen(item.pszText); // 使用 lstrlenW
		i += (strlen + 1) * sizeof(wchar_t); // 宽字符长度计算

		if (flags == 0) {
			item.iItem = idx + 1;
			item.iSubItem = 0;
			idx = (int)sendMsg(LVM_INSERTITEMW, 0, reinterpret_cast<LPARAM>(&item)); // 使用 LVM_INSERTITEMW
			if (idx == -1) {
				error = true;
				break;
			}
		}
		else if (flags == 1) {
			item.iSubItem++;
			item.mask = LVIF_TEXT;
			if (item.iImage != -1) {
				item.mask |= LVIF_IMAGE;
			}
			int ret = (int)sendMsg(LVM_SETITEMW, 0, reinterpret_cast<LPARAM>(&item)); // 使用 LVM_SETITEMW
			if (ret == 0) {
				error = true;
				break;
			}
			item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM | LVIF_STATE | LVIF_INDENT;
			item.stateMask = LVIS_STATEIMAGEMASK;
		}
		else {
			// Handle other flags if necessary
		}
	}

	sendMsg(WM_SETREDRAW, TRUE, 0);
	return !error;
}
std::vector<BYTE> DarkMoonUI::zyListView::取表项() {
	std::vector<BYTE> buffer;
	size_t offset = 0;

	// 获取表项数量和列数量
	int count = (int)sendMsg(LVM_GETITEMCOUNT, 0, 0);
	HWND hHeader = (HWND)sendMsg(LVM_GETHEADER, 0, 0);
	int colCount = (int)SendMessage(hHeader, HDM_GETITEMCOUNT, 0, 0);

	// 预分配缓冲区
	size_t buffLen = count * colCount * (21 + 520);
	buffer.resize(buffLen);

	// 临时存储文本的缓冲区
	std::vector<wchar_t> pszText(260, 0);

	// 遍历表项
	LVITEM item = { 0 };
	item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM | LVIF_STATE | LVIF_INDENT;
	item.stateMask = LVIS_STATEIMAGEMASK;
	item.cchTextMax = 260;
	item.pszText = pszText.data();

	for (int idx = 0; idx < count; idx++) {
		ZeroMemory(pszText.data(), pszText.size() * sizeof(wchar_t));
		item.iItem = idx;
		item.iSubItem = 0;

		// 获取主项数据
		if (!sendMsg(LVM_GETITEMW, 0, (LPARAM)&item)) {
			return {}; // 失败返回空字节集
		}

		// 写入标志位
		BYTE flag = 0;
		SetData(buffer, offset, &flag, sizeof(flag));

		// 写入 iImage
		SetData(buffer, offset, &item.iImage, sizeof(item.iImage));

		// 写入 state
		UINT state = (item.state >> 12) - 1;
		SetData(buffer, offset, &state, sizeof(state));

		// 写入 iIndent
		SetData(buffer, offset, &item.iIndent, sizeof(item.iIndent));

		// 写入 lParam
		SetData(buffer, offset, &item.lParam, sizeof(item.lParam));

		// 写入文本
		int strLen = lstrlen(item.pszText);
		SetData(buffer, offset, item.pszText, (strLen + 1) * sizeof(wchar_t));

		// 处理子项
		if (colCount > 1) {
			for (int j = 1; j < colCount; j++) {
				ZeroMemory(pszText.data(), pszText.size() * sizeof(wchar_t));
				item.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_STATE;
				item.iSubItem = j;

				// 获取子项数据
				if (!sendMsg(LVM_GETITEMW, 0, (LPARAM)&item)) {
					return {}; // 失败返回空字节集
				}

				// 写入标志位
				flag = 1;
				SetData(buffer, offset, &flag, sizeof(flag));

				// 写入 iImage
				SetData(buffer, offset, &item.iImage, sizeof(item.iImage));

				// 写入 state
				state = (item.state >> 12) - 1;
				SetData(buffer, offset, &state, sizeof(state));

				// 写入 iIndent
				SetData(buffer, offset, &item.iIndent, sizeof(item.iIndent));

				// 写入 lParam
				SetData(buffer, offset, &item.lParam, sizeof(item.lParam));

				// 写入文本
				strLen = lstrlen(item.pszText);
				SetData(buffer, offset, item.pszText, (strLen + 1) * sizeof(wchar_t));
			}
		}
	}

	// 返回实际使用的字节集
	buffer.resize(offset);
	return buffer;
}
// 辅助函数：将数据写入缓冲区
void DarkMoonUI::zyListView::SetData(std::vector<BYTE>& buffer, size_t& offset, const void* data, size_t size) {
	if (offset + size > buffer.size()) {
		buffer.resize(offset + size);
	}
	memcpy(buffer.data() + offset, data, size);
	offset += size;
}
void DarkMoonUI::zyListView::刷新显示() {
	sendMsg(LVM_REDRAWITEMS, sendMsg(LVM_GETTOPINDEX, 0, 0), sendMsg(LVM_GETCOUNTPERPAGE, 0, 0));
}
int DarkMoonUI::zyListView::取可见第一项() {//取在当前超级列表框中显示的第一条项目的索引。失败返回-1
	return (int)sendMsg(LVM_GETTOPINDEX, 0, 0);
}
int DarkMoonUI::zyListView::取可见表项数() {//取当前在超级列表框的用户区中大约可以显示的项目数量
	return (int)sendMsg(LVM_GETCOUNTPERPAGE, 0, 0);
}
int DarkMoonUI::zyListView::取编辑框句柄() {//当列表框在进行编辑时，返回这引编辑框的句柄
	return (int)sendMsg(LVM_GETEDITCONTROL, 0, 0);
}
void DarkMoonUI::zyListView::取表项间距(short& 参数_水平间距, short& 参数_垂直间距, bool 参数_列表框类型) {//本命令只能取出大图标列表框和小图标列表框的间距。
	int 间距 = (int)sendMsg(LVM_GETITEMSPACING, 参数_列表框类型 ? 1 : 0, 0);
	参数_水平间距 = LOWORD(间距);
	参数_垂直间距 = HIWORD(间距);
}
int DarkMoonUI::zyListView::取坐标表项索引(int 参数_横坐标, int 参数_纵坐标, int& 参数_表项索引, int& 参数_列索引, int& 参数_分组ID) {//从指定坐标中获取表项索引，列表框左上角开始坐标为0。返回"超列命中_"开头常量组合
	LVHITTESTINFO 局部_位置信息;
	局部_位置信息.pt.x = 参数_横坐标;
	局部_位置信息.pt.y = 参数_纵坐标;
	int 局部_返回值 = (int)sendMsg(LVM_SUBITEMHITTEST, 0, (LPARAM)&局部_位置信息);
	参数_表项索引 = 局部_位置信息.iItem;
	参数_列索引 = 局部_位置信息.iSubItem;
	参数_分组ID = 局部_位置信息.iGroup;
	return 局部_位置信息.flags;
}
bool DarkMoonUI::zyListView::取表项位置(int 参数_表项索引, POINT& 参数_坐标位置) {//取出表项在列表框中的坐标位置
	return sendMsg(LVM_GETITEMPOSITION, 参数_表项索引, (LPARAM)&参数_坐标位置) != 0;
}
bool DarkMoonUI::zyListView::取表项矩形(int 参数_表项索引, RECT& 参数_矩形, int 参数_取出类型) {//取出一个项目的矩形位置，可根据 "取出类型"参数，取出各种的矩形位置。成功返回真，失败返回假。
	参数_矩形.left = 参数_取出类型;
	return sendMsg(LVM_GETITEMRECT, 参数_表项索引, (LPARAM)&参数_矩形) != 0;
}
DarkMoonUI::zyLmageList* DarkMoonUI::zyListView::取图片组(int 参数_类型) {//成功返回图片组句柄，失败返回0。
	zyLmageList* pImageList = nullptr;
	if (参数_类型 == LVSIL_NORMAL)
		pImageList = (zyLmageList*)GetMember(L"pImageListBig");
	else if (参数_类型 == LVSIL_SMALL)
		pImageList = (zyLmageList*)GetMember(L"pImageListSmall");
	else if (参数_类型 == LVSIL_STATE)
		pImageList = (zyLmageList*)GetMember(L"pImageListState");
	else if (参数_类型 == LVSIL_GROUPHEADER)
		pImageList = (zyLmageList*)GetMember(L"pImageListGroup");
	if (pImageList != nullptr) {
		pImageList = new zyLmageList;
		pImageList->置句柄((HIMAGELIST)pImageList);
		return pImageList;
	}
	HIMAGELIST himl = (HIMAGELIST)sendMsg(LVM_GETIMAGELIST, 参数_类型, 0);
	pImageList = new zyLmageList;
	pImageList->置句柄(himl);
	pImageList->getObject()->addRef();
	//IUnknown_AddRef (pImageList);
	if (参数_类型 == LVSIL_NORMAL)
		SetMember(L"pImageListBig", (LONG_PTR)pImageList);
	else if (参数_类型 == LVSIL_SMALL)
		SetMember(L"pImageListSmall", (LONG_PTR)pImageList);
	else if (参数_类型 == LVSIL_STATE)
		SetMember(L"pImageListState", (LONG_PTR)pImageList);
	else if (参数_类型 == LVSIL_GROUPHEADER)
		SetMember(L"pImageListGroup", (LONG_PTR)pImageList);
	return pImageList;
}
void DarkMoonUI::zyListView::置图片组(zyLmageList& 参数_图片组, int 参数_类型) {
	zyLmageList* pImageList = nullptr;
	if (参数_类型 == LVSIL_NORMAL)
		pImageList = (zyLmageList*)GetMember(L"pImageListBig");
	else if (参数_类型 == LVSIL_SMALL)
		pImageList = (zyLmageList*)GetMember(L"pImageListSmall");
	else if (参数_类型 == LVSIL_STATE)
		pImageList = (zyLmageList*)GetMember(L"pImageListState");
	else if (参数_类型 == LVSIL_GROUPHEADER)
		pImageList = (zyLmageList*)GetMember(L"pImageListGroup");
	if (pImageList != 0) {
		pImageList->销毁();
        pImageList->getObject()->release();
	}
	pImageList = &参数_图片组;
	pImageList->getObject()->addRef();
	//IUnknown_AddRef (pImageList);
	if (参数_类型 == LVSIL_NORMAL)
		SetMember(L"pImageListBig", (LONG_PTR)pImageList);
	else if (参数_类型 == LVSIL_SMALL)
		SetMember(L"pImageListSmall", (LONG_PTR)pImageList);
	else if (参数_类型 == LVSIL_STATE)
		SetMember(L"pImageListState", (LONG_PTR)pImageList);
	else if (参数_类型 == LVSIL_GROUPHEADER)
		SetMember(L"pImageListGroup", (LONG_PTR)pImageList);
	sendMsg(LVM_SETIMAGELIST, 参数_类型, (LPARAM)参数_图片组.取句柄());
}
DarkMoonUI::zyLmageList DarkMoonUI::zyListView::创建拖放图片组(int 参数_表项索引, POINT& 参数_参考坐标) {
	zyLmageList ImageList;
	HIMAGELIST himl = (HIMAGELIST)sendMsg(LVM_CREATEDRAGIMAGE, 参数_表项索引, (LPARAM)&参数_参考坐标);
	ImageList.置句柄(himl);
	return ImageList;
}
bool DarkMoonUI::zyListView::滚动列表框(int 参数_水平位置, int 参数_垂直位置) {//成功返回真，失败返回假。
	return sendMsg(LVM_SCROLL, 参数_水平位置, 参数_垂直位置) != 0;
}
int DarkMoonUI::zyListView::添加超列扩展风格(int 参数_扩展风格) {//添加超级列表框的各种扩展风格。"常量_超列扩展_" 开头常量。
	return (int)sendMsg(LVM_SETEXTENDEDLISTVIEWSTYLE, 参数_扩展风格, 参数_扩展风格);
}
int DarkMoonUI::zyListView::取超列扩展风格() {//取列表框的所有扩展风格。可用位与操作判断是否有某扩展风格。"超列扩展_" 开头常量。
	return (int)sendMsg(LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0);
}
int DarkMoonUI::zyListView::移除超列扩展风格(int 参数_扩展风格) {//移除超级列表框的扩展风格。返回之前的风格
	return (int)sendMsg(LVM_SETEXTENDEDLISTVIEWSTYLE, 参数_扩展风格, 0);
}
int DarkMoonUI::zyListView::文本色(int 参数_文本色) {//不提供参数为取，提供参数为置。
	if (参数_文本色 == 0) {
		return (int)sendMsg(LVM_GETTEXTCOLOR, 0, 0);
	}
	sendMsg(LVM_SETTEXTCOLOR, 0, 参数_文本色);
	return 参数_文本色;
}
int DarkMoonUI::zyListView::文本背景色(int 参数_文本背景颜色) {//不提供参数为取，提供参数为置。
	if (参数_文本背景颜色 == 0) {
		return (int)sendMsg(LVM_GETTEXTBKCOLOR, 0, 0);
	}
	sendMsg(LVM_SETTEXTBKCOLOR, 0, 参数_文本背景颜色);
	return 参数_文本背景颜色;
}
int DarkMoonUI::zyListView::背景色(int 参数_背景色, bool 参数_是否立即重画) {//不提供参数为取，提供参数为置。返回当前背景色。
	if (参数_背景色 == 0) {
		return (int)sendMsg(LVM_GETBKCOLOR, 0, 0);
	}
	sendMsg(LVM_SETBKCOLOR, 0, 参数_背景色);
	return 参数_背景色;
}
int DarkMoonUI::zyListView::取显示类型() {//超列类型_ 开头常量
	int 风格 = GetStyle();
	if ((风格 & 2) == 0 && (风格 & 1) == 0)
		return 超列类型_大图标;
	else if ((风格 & 2) == 2 && (风格 & 1) == 0)
		return 超列类型_小图标;
	else if ((风格 & 2) == 2 && (风格 & 1) == 1)
		return 超列类型_普通列表;
	else if ((风格 & 2) == 0 && (风格 & 1) == 1)
		return 超列类型_报表列表;
	return -1;
}
bool DarkMoonUI::zyListView::置显示类型(int 参数_显示类型) {//设置列表框的类型
	int 局部_风格;
	int 局部_原风格 = GetStyle();
	局部_原风格 = 局部_原风格 & (~LVS_TYPEMASK);
	switch (参数_显示类型) {
	case 1:
		局部_风格 = LVS_ICON;
		break;
	case 2:
		局部_风格 = LVS_SMALLICON;
		break;
	case 3:
		局部_风格 = LVS_LIST;
		break;
	case 4:
		局部_风格 = LVS_REPORT;
		break;
	default:
		局部_风格 = LVS_ICON;
	}
	SetWindowLongPtr(取窗口句柄(), GWL_STYLE, 局部_原风格 | 局部_风格);
	return true;
}
DarkMoonUI::zyEditBox* DarkMoonUI::zyListView::取编辑框() {//当组合框风格为"组合框_允许编辑"时，获取其中的编辑框控件
	zyEditBox* edit = nullptr;
	HWND hwndItem = (HWND)SendMessage(取窗口句柄(), LVM_GETEDITCONTROL, 0, 0);
	edit->_BindWindow(hwndItem);
	return edit;
}
int DarkMoonUI::zyListView::取表项索引(int 参数_标志, int 参数_起始索引) {//返回表项索引
	return (int)sendMsg(LVM_GETNEXTITEM, 参数_起始索引, 参数_标志);
}
void DarkMoonUI::zyListView::置表项坐标(int 参数_表项索引, int 参数_X, int 参数_Y) {
	POINT pt;
	pt.x = 参数_X;
	pt.y = 参数_Y;
	sendMsg(LVM_SETITEMPOSITION32, 参数_表项索引, (LPARAM)&pt);
}
POINT DarkMoonUI::zyListView::取表项坐标(int 参数_表项索引) {
	POINT pt;
	sendMsg(LVM_GETITEMPOSITION, 参数_表项索引, (LPARAM)&pt);
	return pt;
}
int DarkMoonUI::zyListView::置大图标间距(int 参数_水平间距, int 参数_垂直间距) {//显示类型必须是 大图标列表框
	return (int)sendMsg(LVM_SETICONSPACING, 0, MAKELPARAM(参数_水平间距, 参数_垂直间距));
}